use std::any::Any;
use std::collections::HashMap;
use std::sync::Mutex;

// 事件处理器 trait，所有事件处理函数都需要实现这个 trait
trait EventHandler: Send + Sync {
    fn handle(&self, event_data: &dyn Any);
}

// 函数处理器，包装普通函数作为事件处理器
struct FunctionHandler<F, T>
where
    F: Fn(&T) + Send + Sync + 'static,
    T: 'static,
{
    func: F,
    obj:Option<T>,
}

impl<F, T> EventHandler for FunctionHandler<F, T>
where
    F: Fn(&T) + Send + Sync + 'static,
    T: 'static + std::marker::Send + std::marker::Sync,
{
    fn handle(&self, event_data: &dyn Any) {
        // 尝试将事件数据转换为特定类型并处理
        if let Some(data) = event_data.downcast_ref::<T>() {
            (self.func)(data);
        }
    }
}

// 事件管理器，负责注册事件和触发事件
#[derive(Default)]
pub struct EventManager {
    // 使用 HashMap 存储不同类型事件的处理器列表
    handlers: Mutex<HashMap<String, Vec<Box<dyn EventHandler>>>>,
}

impl EventManager {
    // 创建新的事件管理器
    pub fn new() -> Self {
        EventManager::default()
    }

    // 注册事件处理器
    pub fn on<F, T>(&self, handler: F)
    where
        F: Fn(&T) + Send + Sync + 'static,
        T: 'static + std::marker::Send + std::marker::Sync,
    {
        // 获取事件类型的唯一标识
        let event_type = std::any::type_name::<T>().to_string();

        // 将函数包装为事件处理器并添加到列表
        let function_handler = Box::new(FunctionHandler { func: handler, obj: Option::None });

        let mut handlers = self.handlers.lock().unwrap();
        handlers.entry(event_type)
            .or_insert_with(Vec::new)
            .push(function_handler);
    }

    // 触发事件
    pub fn emit<T: 'static>(&self, event_data: &T) {
        let event_type = std::any::type_name::<T>().to_string();

        // 通知所有注册的事件处理器
        let handlers = self.handlers.lock().unwrap();
        if let Some(handlers) = handlers.get(&event_type) {
            for handler in handlers {
                handler.handle(event_data);
            }
        }
    }
}

fn test() {
    let event_manager = EventManager::new();

    // 定义事件数据结构
    #[derive(Debug)]
    struct MouseClickEvent {
        x: i32,
        y: i32,
        button: u8,
    }

    #[derive(Debug)]
    struct KeyPressEvent {
        key_code: u32,
        is_shift_pressed: bool,
    }

    // 注册鼠标点击事件处理器
    event_manager.on(|event: &MouseClickEvent| {
        println!("Mouse clicked at ({}, {}), button: {}", event.x, event.y, event.button);
    });

    // 注册另一个鼠标点击事件处理器
    event_manager.on(|event: &MouseClickEvent| {
        println!("Received mouse click event: {:?}", event);
    });

    // 注册键盘按键事件处理器
    event_manager.on(|event: &KeyPressEvent| {
        println!("Key pressed: {}, Shift: {}", event.key_code, event.is_shift_pressed);
    });

    // 触发鼠标点击事件
    event_manager.emit(&MouseClickEvent {
        x: 150,
        y: 300,
        button: 1,
    });

    // 触发键盘按键事件
    event_manager.emit(&KeyPressEvent {
        key_code: 65,  // 'A' 键
        is_shift_pressed: true,
    });
}